/*
    * Copyright (C) 2007 The Guava Authors
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.google.common.base;
  
  import com.google.common.annotations.GwtCompatible;
  import com.google.common.collect.Lists;
  import com.google.common.testing.EqualsTester;
  
  import junit.framework.TestCase;
  
  import java.io.Serializable;
  import java.util.ArrayList;
  import java.util.List;
  
  /**
   * Tests com.google.common.base.Suppliers.
   *
   * @author Laurence Gonsalves
   * @author Harry Heymann
   */
  @GwtCompatible(emulated = true)
  public class SuppliersTest extends TestCase {
    public void testCompose() {
      Supplier<Integer> fiveSupplier = new Supplier<Integer>() {
        @Override
        public Integer get() {
          return 5;
        }
      };
  
      Function<Number, Integer> intValueFunction =
          new Function<Number, Integer>() {
            @Override
            public Integer apply(Number x) {
              return x.intValue();
            }
          };
  
      Supplier<Integer> squareSupplier = Suppliers.compose(intValueFunction,
          fiveSupplier);
  
      assertEquals(Integer.valueOf(5), squareSupplier.get());
    }
  
    public void testComposeWithLists() {
      Supplier<ArrayList<Integer>> listSupplier
          = new Supplier<ArrayList<Integer>>() {
        @Override
        public ArrayList<Integer> get() {
          return Lists.newArrayList(0);
        }
      };
  
      Function<List<Integer>, List<Integer>> addElementFunction =
          new Function<List<Integer>, List<Integer>>() {
            @Override
            public List<Integer> apply(List<Integer> list) {
              ArrayList<Integer> result = Lists.newArrayList(list);
              result.add(1);
              return result;
            }
          };
  
      Supplier<List<Integer>> addSupplier = Suppliers.compose(addElementFunction,
          listSupplier);
  
      List<Integer> result = addSupplier.get();
      assertEquals(Integer.valueOf(0), result.get(0));
      assertEquals(Integer.valueOf(1), result.get(1));
    }
  
    static class CountingSupplier implements Supplier<Integer>, Serializable {
      private static final long serialVersionUID = 0L;
      transient int calls = 0;
      @Override
      public Integer get() {
        calls++;
        return calls * 10;
      }
    }
  
    public void testMemoize() {
      CountingSupplier countingSupplier = new CountingSupplier();
      Supplier<Integer> memoizedSupplier = Suppliers.memoize(countingSupplier);
      checkMemoize(countingSupplier, memoizedSupplier);
   }
 
   public void testMemoize_redudantly() {
     CountingSupplier countingSupplier = new CountingSupplier();
     Supplier<Integer> memoizedSupplier = Suppliers.memoize(countingSupplier);
     assertSame(memoizedSupplier, Suppliers.memoize(memoizedSupplier));
   }
 
   private void checkMemoize(
       CountingSupplier countingSupplier, Supplier<Integer> memoizedSupplier) {
     // the underlying supplier hasn't executed yet
     assertEquals(0, countingSupplier.calls);
 
     assertEquals(10, (int) memoizedSupplier.get());
 
     // now it has
     assertEquals(1, countingSupplier.calls);
 
     assertEquals(10, (int) memoizedSupplier.get());
 
     // it still should only have executed once due to memoization
     assertEquals(1, countingSupplier.calls);
   }
 
   public void testMemoizeExceptionThrown() {
     Supplier<Integer> exceptingSupplier = new Supplier<Integer>() {
       @Override
       public Integer get() {
         throw new NullPointerException();
       }
     };
 
     Supplier<Integer> memoizedSupplier = Suppliers.memoize(exceptingSupplier);
 
     // call get() twice to make sure that memoization doesn't interfere
     // with throwing the exception
     for (int i = 0; i < 2; i++) {
       try {
         memoizedSupplier.get();
         fail("failed to throw NullPointerException");
       } catch (NullPointerException e) {
         // this is what should happen
       }
     }
   }
 
   public void testOfInstanceSuppliesSameInstance() {
     Object toBeSupplied = new Object();
     Supplier<Object> objectSupplier = Suppliers.ofInstance(toBeSupplied);
     assertSame(toBeSupplied,objectSupplier.get());
     assertSame(toBeSupplied,objectSupplier.get()); // idempotent
   }
 
   public void testOfInstanceSuppliesNull() {
     Supplier<Integer> nullSupplier = Suppliers.ofInstance(null);
     assertNull(nullSupplier.get());
   }
 
   public void testSupplierFunction() {
     Supplier<Integer> supplier = Suppliers.ofInstance(14);
     Function<Supplier<Integer>, Integer> supplierFunction =
         Suppliers.supplierFunction();
 
     assertEquals(14, (int) supplierFunction.apply(supplier));
   }
 
   public void testOfInstance_equals() {
     new EqualsTester()
         .addEqualityGroup(
             Suppliers.ofInstance("foo"), Suppliers.ofInstance("foo"))
         .addEqualityGroup(Suppliers.ofInstance("bar"))
         .testEquals();
   }
 
   public void testCompose_equals() {
     new EqualsTester()
         .addEqualityGroup(
             Suppliers.compose(Functions.constant(1), Suppliers.ofInstance("foo")),
             Suppliers.compose(Functions.constant(1), Suppliers.ofInstance("foo")))
         .addEqualityGroup(
             Suppliers.compose(Functions.constant(2), Suppliers.ofInstance("foo")))
         .addEqualityGroup(
             Suppliers.compose(Functions.constant(1), Suppliers.ofInstance("bar")))
         .testEquals();
   }
 }